using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("FixedRewardsMgr")]
	public class FixedRewardsMgr : MonoClass
	{
		[Attribute38("FixedRewardsMgr.FixedMetaActionReward")]
		public class FixedMetaActionReward : MonoClass
		{
			public int MetaActionID => method_11<int>("get_MetaActionID", Array.Empty<object>());

			public ulong MetaActionFlags => method_11<ulong>("get_MetaActionFlags", Array.Empty<object>());

			public FixedMetaActionReward(IntPtr address, string className)
				: base(address, className)
			{
			}

			public FixedMetaActionReward(IntPtr address)
				: this(address, "FixedMetaActionReward")
			{
			}

			public void UpdateFlags(ulong addFlags, ulong removeFlags)
			{
				method_8("UpdateFlags", addFlags, removeFlags);
			}

			public bool HasAllRequiredFlags(ulong requiredFlags)
			{
				return method_11<bool>("HasAllRequiredFlags", new object[1] { requiredFlags });
			}
		}

		[Attribute38("FixedRewardsMgr.FixedReward")]
		public class FixedReward : MonoClass
		{
			public FixedRewardType Type => method_2<FixedRewardType>("Type");

			public CardRewardData FixedCardRewardData => method_3<CardRewardData>("FixedCardRewardData");

			public CardBackRewardData FixedCardBackRewardData => method_3<CardBackRewardData>("FixedCardBackRewardData");

			public NetCache.CardDefinition FixedCraftableCardRewardData => method_3<NetCache.CardDefinition>("FixedCraftableCardRewardData");

			public FixedMetaActionReward FixedMetaActionRewardData => method_3<FixedMetaActionReward>("FixedMetaActionRewardData");

			public FixedReward(IntPtr address, string className)
				: base(address, className)
			{
			}

			public FixedReward(IntPtr address)
				: this(address, "FixedReward")
			{
			}
		}

		[Attribute38("FixedRewardsMgr.OnAllFixedRewardsShownCallbackInfo")]
		public class OnAllFixedRewardsShownCallbackInfo : MonoClass
		{
			public List<RewardMapIDToShow> m_rewardMapIDsToShow => method_3<Class271<RewardMapIDToShow>>("m_rewardMapIDsToShow")?.method_25();

			public Vector3 m_rewardPunchScale => method_2<Vector3>("m_rewardPunchScale");

			public Vector3 m_rewardScale => method_2<Vector3>("m_rewardScale");

			public object m_userData => method_3<object>("m_userData");

			public bool m_showingCheatRewards => method_2<bool>("m_showingCheatRewards");

			public OnAllFixedRewardsShownCallbackInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public OnAllFixedRewardsShownCallbackInfo(IntPtr address)
				: this(address, "OnAllFixedRewardsShownCallbackInfo")
			{
			}
		}

		[Attribute38("FixedRewardsMgr.RewardMapIDToShow")]
		public class RewardMapIDToShow : MonoClass
		{
			public static int NO_ACHIEVE_ID => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "FixedRewardsMgr/RewardMapIDToShow", "NO_ACHIEVE_ID");

			public int RewardMapID => method_2<int>("RewardMapID");

			public int AchieveID => method_2<int>("AchieveID");

			public int SortOrder => method_2<int>("SortOrder");

			public RewardMapIDToShow(IntPtr address, string className)
				: base(address, className)
			{
			}

			public RewardMapIDToShow(IntPtr address)
				: this(address, "RewardMapIDToShow")
			{
			}

			public new bool Equals(object obj)
			{
				return method_11<bool>("Equals", new object[1] { obj });
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		public enum ShowVisualOption
		{
			DO_NOT_SHOW,
			SHOW,
			FORCE_SHOW
		}

		public bool m_registeredForAdventureProgressUpdates => method_2<bool>("m_registeredForAdventureProgressUpdates");

		public bool m_registeredForProfileNotices => method_2<bool>("m_registeredForProfileNotices");

		public bool m_registeredForCompletedAchieves => method_2<bool>("m_registeredForCompletedAchieves");

		public bool m_isStartupFinished => method_2<bool>("m_isStartupFinished");

		public bool m_isInitialization => method_2<bool>("m_isInitialization");

		public FixedRewardsMgr(IntPtr address, string className)
			: base(address, className)
		{
		}

		public FixedRewardsMgr(IntPtr address)
			: this(address, "FixedRewardsMgr")
		{
		}

		public static void Initialize()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "FixedRewardsMgr", "Initialize");
		}

		public static FixedRewardsMgr Get()
		{
			return MonoClass.smethod_15<FixedRewardsMgr>(TritonHs.MainAssemblyPath, "", "FixedRewardsMgr", "Get", Array.Empty<object>());
		}

		public void CheckForTutorialComplete()
		{
			method_9("CheckForTutorialComplete", new Class276.Enum20[0]);
		}

		public bool IsStartupFinished()
		{
			return method_11<bool>("IsStartupFinished", Array.Empty<object>());
		}

		public void InitStartupFixedRewards()
		{
			method_8("InitStartupFixedRewards");
		}

		public bool HasRewardsToShow(RewardVisualTiming rewardVisualTiming)
		{
			return method_11<bool>("HasRewardsToShow", new object[1] { rewardVisualTiming });
		}

		public bool CanCraftCard(string cardID, TAG_PREMIUM premium)
		{
			return method_11<bool>("CanCraftCard", new object[2] { cardID, premium });
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void OnAdventureProgressUpdate(bool isStartupAction, AdventureMission.WingProgress oldProgress, AdventureMission.WingProgress newProgress, object userData)
		{
			method_8("OnAdventureProgressUpdate", isStartupAction, oldProgress, newProgress, userData);
		}

		public FixedMetaActionReward GetEarnedMetaActionReward(int metaActionID)
		{
			return method_14<FixedMetaActionReward>("GetEarnedMetaActionReward", new object[1] { metaActionID });
		}

		public void UpdateEarnedMetaActionFlags(int metaActionID, ulong addFlags, ulong removeFlags)
		{
			method_8("UpdateEarnedMetaActionFlags", metaActionID, addFlags, removeFlags);
		}

		public NetCache.CardDefinition GetCardDefinition(FixedRewardDbfRecord dbfRecReward)
		{
			return method_14<NetCache.CardDefinition>("GetCardDefinition", new object[1] { dbfRecReward });
		}

		public FixedReward GetFixedReward(FixedRewardMapDbfRecord fixedRewardMapRecord)
		{
			return method_14<FixedReward>("GetFixedReward", new object[1] { fixedRewardMapRecord });
		}

		public bool QueueRewardVisual(FixedRewardMapDbfRecord fixedRewardMapRecord, int achieveID)
		{
			return method_11<bool>("QueueRewardVisual", new object[2] { fixedRewardMapRecord, achieveID });
		}

		public void ShowFixedRewards_Internal(UserAttentionBlocker blocker, OnAllFixedRewardsShownCallbackInfo callbackInfo)
		{
			method_8("ShowFixedRewards_Internal", blocker, callbackInfo);
		}

		public void OnNonToastRewardClicked(Reward reward, object userData)
		{
			method_8("OnNonToastRewardClicked", reward, userData);
		}
	}
}
